package com.itheima.stream;

import java.io.FileInputStream;
import java.io.IOException;

/**
 * 2025/4/26 11:17
 * 演示FileInputStream的使用,案例-读取a.txt文件到内存中
 * <p>
 * 步骤：
 * --1. 创建一个FileInputStream对象，构造方法中传递读取数据的文件
 * --2. 使用FileInputStream对象中的方法read读取文件
 * --3. close释放资源
 * <p>
 * 构造函数：
 * --1. FileInputStream(String filePath)
 * 成员方法：
 * --1. byte[] readAllBytes()：读取文件所有字节，返回字节数组
 * --2. int read()：读取一个字节，返回读取的字节，如果已经到达文件末尾，返回-1
 * --3. int read(byte[] b)：读取多个字节，将读到的字节放到字节数组中，返回读取的字节个数，如果已经到达文件末尾，返回-1
 * <p>
 * <p>
 * 补充知识：
 * String类的构造函数，将字节数组中的一部分转换为字符串
 * --1. String(byte[] bytes)：将字节数组转换成字符串
 * --2. String(byte[] bytes, int offset, int length)：将字节数组中一部分转换成字符串
 */
public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        test3();
    }

    //一次读多个字节，读取到字节数组中，提高读的效率
    //打断点
    public static void test3() throws IOException {
        FileInputStream fis = new FileInputStream("day11-io/info.txt");

        byte[] bytes = new byte[4];
        //记录读取的字节个数，如果-1，则说明已经到达文件末尾，跳出while循环
        int len;
        while ((len = fis.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, len));
        }

//        while(true){
//            len = fis.read(bytes);
//            if (len==-1){
//                break;
//            }
//            System.out.println(new String(bytes,0,len));
//        }



       /* // 调用一次读取多个字节，将读到的字节放到字节数组中，返回读取的字节个数，如果已经到达文件末尾，返回-1
        int len1 = fis.read(bytes);
        //将bytes数组转换成字符串
        String str1 = new String(bytes);
        System.out.println("len1 = "+len1);
        System.out.println(str1);

        int len2 = fis.read(bytes);
        //将bytes数组转换成字符串
        String str2 = new String(bytes);
        System.out.println("len2 = "+len2);
        System.out.println(str2);

        int len3 = fis.read(bytes);
        //将bytes数组转换成字符串
        String str3 = new String(bytes,0,len3);//ed--->e
        System.out.println("len3 = "+len3);
        System.out.println(str3);

        int len4 = fis.read(bytes);
        System.out.println("len4 = "+len4);*/


        fis.close();
    }


    //一次读一个字节
    private static void test2() throws IOException {
        FileInputStream fis = new FileInputStream("day11-io/info.txt");
        //调用一次读取一个字节，并返回。如果读到文件的结尾了，则返回-1
       /* int b1 = fis.read();//97
        System.out.println(b1+"====>"+(char)b1);//97

        int b2 = fis.read();
        System.out.println(b2+"====>"+(char)b2);

        int b3 = fis.read();
        System.out.println(b3+"====>"+(char)b3);

        int b4 = fis.read();
        System.out.println(b4+"====>"+(char)b4);

        int b5 = fis.read();
        System.out.println(b5+"====>"+(char)b5);*/

        int b;//记录每次读到的字节的值
        while ((b = fis.read()) != -1) {
            System.out.print((char) b);
        }
//        while(true){
//            b = fis.read();
//            if (b == -1){
//                break;
//            }
//            System.out.println(b);
//        }
        //关闭流
        fis.close();
    }

    /**
     * 一次读取所有字节
     *
     * @throws IOException
     */
    private static void test1() throws IOException {
        //1. 创建一个FileInputStream对象，构造方法中传递读取数据的文件
        FileInputStream fis = new FileInputStream("day11-io/info.txt");
        //2. read方法读取文件
        //一次性读取文件的所有字节
        /*
         最大只能读取2^31个字节byte--/2^10(1024)---->2^21kb---/1024-->2^11mb--/1024--->2GB
        注意：如果目标文件特别大，不能超过2G，出异常
        适合读取小文件。
         */
        byte[] bytes = fis.readAllBytes();
        //将字节数组转换成字符串（String类）
        String data = new String(bytes);//默认使用的也是utf-8编码
        System.out.println(data);
        //3.关闭资源
        fis.close();
    }
}
